home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 293_02 / gra.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-08-23  |  5.9 KB  |  195 lines
  1. /************************ gra.c *************************************
  2.  
  3.       3-D Reconstruction of Medical Images
  4.  
  5.     Three Dimensional Reconstruction Of Medical
  6.     Images from Serial Slices - CT, MRI, Ultrasound
  7.  
  8.  
  9.    These programs process a set of slices images (scans) for one
  10.    patient. It outputs two sets of files containing nine predefined
  11.    views of bony surfaces. One set contains distance values and
  12.    the other gradient values.
  13.  
  14.    The distance values are used as 3-D spatial topographic surface
  15.    coordinate maps for geometrical analysis of the scanned object.
  16.  
  17.    The gradient values are used for rendering the surface maps on
  18.    CRT displays for subjective viewing where perception of small
  19.    surface details is important.
  20.  
  21.     Daniel Geist, B.S.
  22.     Michael W. Vannier, M.D.
  23.  
  24.     Mallinckrodt Institute of Radiology
  25.     Washington University School of Medicine
  26.     510 S. Kingshighway Blvd.
  27.     St. Louis, Mo. 63110
  28.  
  29.     These programs may be copied and used freely for non-commercial
  30.     purposes by developers with inclusion of this notice.
  31.  
  32.  
  33. ********************************************************************/
  34. #include <stdio.h>
  35. #include <math.h>
  36. #define DZ    3.0
  37. #define DX    1.0
  38. #define DY    1.0
  39. int outfile,ZMAX,FIRSTSLICE,LASTSLICE,THRESHOLD,ZOOM,
  40.     RIGHTMID,LEFTMID,TOPINT,midslice,midline;
  41. int huge buffer[16][16][256];
  42. FILE *fg,*fd;
  43. /*            standard 18 output files ( 9 views x 2) */
  44. char *fnamein="ctbild.000",*fgll="gll.out",*fdll="dll.out";
  45. succ(i)
  46. int i;
  47. {return(i==14?0:i+1);}
  48. prev(i)
  49. int i;
  50. {return(i==0?14:i-1);}
  51. setfilename(filenum)
  52. int filenum;
  53. {fnamein[7]=filenum/100+'0';
  54.  fnamein[8]=(filenum%100)/10+'0';
  55.  fnamein[9]='0'+filenum%10;
  56. }
  57. interpolate(slice,line)
  58. int slice,line;
  59. {int next,endslice,i,j,x;
  60.  next=succ(slice);
  61.  endslice=slice+ZOOM;
  62.  if(endslice>15) endslice-=16;
  63.  for(i=1,j=ZOOM-1;i<ZOOM;i++,j--){
  64.       for(x=0;x<256;x++) buffer[next][line][x]=
  65.               (buffer[slice][line][x]*j+buffer[endslice][line][x]*i)/ZOOM;
  66.       next=succ(next);
  67.  }
  68. }
  69. readline(filenum,line,bufslice,bufline)
  70. int filenum,line,bufslice,bufline;
  71. {FILE *fn;
  72.  setfilename(filenum);
  73.  fn=fopen(fnamein,"rb");
  74.  fseek(fn,(long)512*(line+1),SEEK_SET);
  75.  fread(buffer[bufslice][bufline],1,512,fn);
  76.  fclose(fn);
  77. }
  78. readsection(firstfile,bufslice,bufline,line)
  79. int firstfile,bufslice,bufline,line;
  80. {int file,k,slice;
  81.  for(file=firstfile,slice=bufslice,k=0;k<16;file++,k+=ZOOM,slice+=ZOOM){
  82.        if(slice>15)slice-=16;
  83.        readline(file,line,slice,bufline); 
  84.  }
  85.  if(ZOOM>1) for(slice=bufslice,k=0;k<16-ZOOM;k+=ZOOM,slice+=ZOOM){
  86.        if(slice>15)slice-=16;
  87.        interpolate(slice,bufline);
  88.  }
  89. }
  90. readblock(firstfile)
  91. int firstfile;
  92. {int i;
  93.   for(i=0;i<16;i++) readsection(firstfile,0,i,i);
  94. }
  95. /******************* VAR1X ****************************/
  96. /*place of change on x axis reference to point (positive search) */
  97. double var1x(x,y,z,zero)
  98. int x,y,z,zero;
  99. {int i;
  100.  double delta1,delta;
  101.   i=x;
  102.   while((buffer[z][y][i]>=THRESHOLD)&&(i>0))i--;
  103.   if(buffer[z][y][i]>=THRESHOLD)return(DX*(i-x));
  104.   while((buffer[z][y][i]<THRESHOLD)&&(i<255))i++;
  105.   if(buffer[z][y][i]<THRESHOLD)return(DX*(i-x));
  106.   else {
  107.         delta1=THRESHOLD-buffer[z][y][i];
  108.         delta=buffer[z][y][i]-buffer[z][y][i-1];
  109.        return((delta1/delta+i-x)*DX);
  110.   }
  111. }
  112.  
  113. /**************** GETGRADX ***************************************/
  114. /* grad=  2048*(normalized @F/@x of surface func F)              */
  115. /*****************************************************************/
  116. unsigned char getgradx(func,x,y,slice,limit)
  117. int func,x,y,slice,limit;
  118. {double sy[2],sz[2],gx,gy,gz;
  119.  unsigned char gxint;
  120.      /* get x and y components of gradient */
  121.   sz[0]=var1x(x,y,prev(slice),limit);
  122.   sz[1]=var1x(x,y,succ(slice),limit);
  123.   gz=(sz[1]-sz[0])/(2*DZ);
  124.   sy[0]=var1x(x,prev(y),slice,limit);
  125.   sy[1]=var1x(x,succ(y),slice,limit);
  126.   gy=(sy[1]-sy[0])/(2*DY);
  127.      /*compute gx - normalized x component of gradient */
  128.   gx=1/sqrt(1+gz*gz+gy*gy);
  129.   gxint=256*gx+0.5;      /*scale gx by 256 */
  130.   return(gxint);
  131. }
  132. slice_pass(midslice,startfile,z)
  133. int midslice,startfile,z;
  134. { int midline,i,x,y;
  135.   char lined[256],lineg[256];
  136.    for(i=0;i<256;i++){
  137.         lineg[i]=0;
  138.         lined[i]=0;
  139.    }
  140.    midline=1;
  141.    for(y=1;y<255;y++){ /*for each line*/
  142.          for(x=1;x<255;x++)   /*for each pixel*/
  143.          if((buffer[midslice][midline][x]>=THRESHOLD)&&(lined[y]==0)){
  144.                    lineg[y]=getgradx(0,x,midline,midslice,0);
  145.                    lined[y]=255-x;
  146.          }
  147.          midline=succ(midline);
  148.          if((y>6)&&(y<247))
  149.              readsection(startfile,0,
  150.                             midline>6?midline-7:midline+9,y);
  151.    printf("%d ",y);
  152.    }
  153.    fwrite(lineg,1,256,fg);
  154.    fwrite(lined,1,256,fd);
  155. }
  156. /**********************************************************/
  157. /**** MAIN ***** MAIN ***** MAIN ***** MAIN ***** MAIN ****/
  158. /**********************************************************/
  159. main()
  160. {int z,i,j,k,r,startfile;
  161.  midslice=1;
  162. /* first get some parameters from user */
  163.  printf("Enter Zoom factor: ");
  164.  scanf("%d",&ZOOM);
  165.  printf("Enter Starting scan number: ");
  166.  scanf("%d",&FIRSTSLICE);
  167.  printf("Enter ending scan number: ");
  168.  scanf("%d",&LASTSLICE);
  169.  ZMAX=LASTSLICE-FIRSTSLICE+1;
  170.  printf("Enter threshold number: ");
  171.  scanf("%d",&THRESHOLD);
  172.  THRESHOLD+=1024;
  173.  
  174.  /*creat files for first pass */
  175.  fd=fopen(fdll,"w+b");
  176.  fg=fopen(fgll,"w+b");
  177.  /* read first block of scans */
  178.  readblock(FIRSTSLICE);
  179.  startfile=FIRSTSLICE;
  180.  
  181.  /* first pass on scan data (forward) */
  182.  printf("Begining computation of REAR,LEFT,REAR,and LEFT-MID views\n");
  183.  for(z=0;z<LASTSLICE-FIRSTSLICE;z++){                 /*for each slice */
  184.     for(i=1;i<=ZOOM;i++,midslice++)slice_pass(midslice,startfile,z*ZOOM+i);
  185.     printf("did slice %d\n",z);
  186.     if(((z+1)*ZOOM>8)&&((LASTSLICE-startfile)*ZOOM+1>16)){
  187.         startfile++;
  188.         midslice-=ZOOM;
  189.     }
  190.     readblock(startfile);
  191.  }
  192.  fclose(fg);
  193.  fclose(fd);
  194. }
  195.